package com.doform.android.xianggucheng.utils;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.media.ExifInterface;
import android.util.Base64;

import java.io.ByteArrayOutputStream;
import java.io.IOException;

/**
 * Created by ph on 2017/6/19.
 */

public class BitMapUtil {
    /**
     * Get bitmap from specified image path
     *
     * @param imgPath
     * @return
     */
    public Bitmap getBitmap(String imgPath) {
        // Get bitmap through image path
        BitmapFactory.Options newOpts = new BitmapFactory.Options();
        newOpts.inJustDecodeBounds = false;
        newOpts.inPurgeable = true;
        newOpts.inInputShareable = true;
        // Do not compress
        newOpts.inSampleSize = 1;
        newOpts.inPreferredConfig = Bitmap.Config.RGB_565;
        return BitmapFactory.decodeFile(imgPath, newOpts);
    }

    //计算图片的缩放值
    public static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
        final int height = options.outHeight;
        final int width = options.outWidth;
        int inSampleSize = 1;

        if (height > reqHeight || width > reqWidth) {
            final int heightRatio = Math.round((float) height / (float) reqHeight);
            final int widthRatio = Math.round((float) width / (float) reqWidth);
//            inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
            inSampleSize = Math.max(heightRatio, widthRatio);
        }
        return inSampleSize;
    }

    /**
     * 根据路径获得图片并压缩，返回bitmap用于显示
     *
     * @param filePath
     * @return
     */

    public static Bitmap getSmallBitmap(String filePath) {
        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(filePath, options);

        // Calculate inSampleSize
        options.inSampleSize = calculateInSampleSize(options, 480, 800);

        // Decode bitmap with inSampleSize set
        options.inJustDecodeBounds = false;

        return BitmapFactory.decodeFile(filePath, options);
    }

   /* */

    /**
     * 压缩图片，处理某些手机拍照角度旋转的问题
     *//*
    public static String compressImage(Context mContext, String filePath, String fileName, int q) throws FileNotFoundException {

        Bitmap bm = getSmallBitmap(filePath);

        int degree = readPictureDegree(filePath);

        if(degree!=0){//旋转照片角度
            bm=rotateBitmap(bm,degree);
        }

        File imageDir = SDCardUtils.getImageDir(mContext) ;

        File outputFile=new File(imageDir,fileName);

        FileOutputStream out = new FileOutputStream(outputFile);

        bm.compress(Bitmap.CompressFormat.JPEG, q, out);

        return outputFile.getPath();
    }*/
    public static int readPictureDegree(String path) {
        int degree = 0;
        try {
            ExifInterface exifInterface = new ExifInterface(path);
            int orientation = exifInterface.getAttributeInt(
                    ExifInterface.TAG_ORIENTATION,
                    ExifInterface.ORIENTATION_NORMAL);
            switch (orientation) {
                case ExifInterface.ORIENTATION_ROTATE_90:
                    degree = 90;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_180:
                    degree = 180;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_270:
                    degree = 270;
                    break;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return degree;
    }

    public static Bitmap rotateBitmap(Bitmap bitmap, int degress) {
        if (bitmap != null) {
            Matrix m = new Matrix();
            m.postRotate(degress);
            bitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), m, true);
            return bitmap;
        }
        return bitmap;
    }

    /**
     * 图片压缩并进行base64转码
     *
     * @param imgPath
     * @param reqWidth
     * @param reqHeight
     * @param maxSizeKB
     * @param imgFormat
     * @return
     */
    public static String imgCompress(String imgPath, int reqWidth, int reqHeight, int maxSizeKB, String imgFormat) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        BitmapFactory.Options opt = new BitmapFactory.Options();
        opt.inJustDecodeBounds = true;
        opt.inSampleSize = 1;
        opt.inPreferredConfig = Bitmap.Config.RGB_565;
        BitmapFactory.decodeFile(imgPath, opt);
        int outWidth = opt.outWidth;
        int outHeight = opt.outHeight;
        if (outHeight > reqHeight || outWidth > reqWidth) {
            final int heightRatio = Math.round((float) outHeight / (float) reqHeight);
            final int widthRatio = Math.round((float) outWidth / (float) reqWidth);
//            opt.inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
            opt.inSampleSize = Math.max(heightRatio, widthRatio);
        }
        opt.inJustDecodeBounds = false;
        Bitmap bitmap = BitmapFactory.decodeFile(imgPath, opt);

        Bitmap.CompressFormat compressFormat =  Bitmap.CompressFormat.JPEG;

        if (imgFormat.equals("jpg")||imgFormat.equals("jpeg")) {
            compressFormat = Bitmap.CompressFormat.JPEG;
        } else if (imgFormat.equals("png")) {
            compressFormat = Bitmap.CompressFormat.PNG;
        } /*else if (imgFormat.equals("gif")) {
            compressFormat=Bitmap.CompressFormat.WEBP;
            *//*File file = new File(imgPath);
            try {
                FileInputStream fis = new FileInputStream(file);
                ByteArrayOutputStream os = new ByteArrayOutputStream();
                int len = -1;
                byte[] b = new byte[1024];
                while ((len = fis.read(b)) == -1) {
                    os.write(b);
                }
                base64Str=Base64.encodeToString(os.toByteArray(), Base64.DEFAULT);
                return base64StrHead + base64Str;
            } catch (Exception e) {
                e.printStackTrace();
                return "";
            }*//*
        }*/
        if (bitmap == null) return "";
        bitmap.compress(compressFormat, 100, baos);
        int quality ;
        while (baos.toByteArray().length / 1024 > maxSizeKB) {
            if (baos.toByteArray().length / 1024 > maxSizeKB * 2) {
                quality = 50;
            } else {
                quality = 90;
            }
            baos.reset();
            bitmap.compress(compressFormat, quality, baos);
        }
        String base64Str = Base64.encodeToString(baos.toByteArray(), Base64.DEFAULT);
        String base64StrHead = "data:image/" + imgFormat + ";base64,";

        return base64StrHead + base64Str;
    }
}
